// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.platformshipping.item;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.PlatformshippingItem;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(PlatformshippingItem.class)
@Setter
@Getter
public class PlatformshippingItemSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "PlatformshippingItem".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentPlatformshipping", "p");
    map.put("productName", "p2");
    map.put("shopId", "si");
    map.put("shippingwarehousestore", "si2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属平台仓发货单
   */
  private Long parentPlatformshipping;

  /**
   * 所属平台仓发货单 比较(eq)
   */
  private Long parentPlatformshippingEq;
  /**
   * 所属平台仓发货单 比较(neq)
   */
  private Long parentPlatformshippingNeq;
  /**
   * 所属平台仓发货单 比较(gt)
   */
  private Long parentPlatformshippingGt;
  /**
   * 所属平台仓发货单 比较(gte)
   */
  private Long parentPlatformshippingGte;
  /**
   * 所属平台仓发货单 比较(lt)
   */
  private Long parentPlatformshippingLt;
  /**
   * 所属平台仓发货单 比较(lte)
   */
  private Long parentPlatformshippingLte;
  /**
   * 所属平台仓发货单 比较(contains)
   */
  private Long parentPlatformshippingContains;
  /**
   * 所属平台仓发货单 比较(notcontains)
   */
  private Long parentPlatformshippingNotcontains;
  /**
   * 所属平台仓发货单 比较(startswith)
   */
  private Long parentPlatformshippingStartswith;
  /**
   * 所属平台仓发货单 比较(endswith)
   */
  private Long parentPlatformshippingEndswith;
  /**
   * 所属平台仓发货单 比较(isnull)
   */
  private Boolean parentPlatformshippingIsnull;
  /**
   * 所属平台仓发货单 比较(isnotnull)
   */
  private Boolean parentPlatformshippingIsnotnull;
  /**
   * 所属平台仓发货单的发货单号 比较(eq)
   */
  private String parentPlatformshippingShipmentCodeEq;
  /**
   * 所属平台仓发货单的发货单号 比较(neq)
   */
  private String parentPlatformshippingShipmentCodeNeq;
  /**
   * 所属平台仓发货单的发货单号 比较(gt)
   */
  private String parentPlatformshippingShipmentCodeGt;
  /**
   * 所属平台仓发货单的发货单号 比较(gte)
   */
  private String parentPlatformshippingShipmentCodeGte;
  /**
   * 所属平台仓发货单的发货单号 比较(lt)
   */
  private String parentPlatformshippingShipmentCodeLt;
  /**
   * 所属平台仓发货单的发货单号 比较(lte)
   */
  private String parentPlatformshippingShipmentCodeLte;
  /**
   * 所属平台仓发货单的发货单号 比较(contains)
   */
  private String parentPlatformshippingShipmentCodeContains;
  /**
   * 所属平台仓发货单的发货单号 比较(notcontains)
   */
  private String parentPlatformshippingShipmentCodeNotcontains;
  /**
   * 所属平台仓发货单的发货单号 比较(startswith)
   */
  private String parentPlatformshippingShipmentCodeStartswith;
  /**
   * 所属平台仓发货单的发货单号 比较(endswith)
   */
  private String parentPlatformshippingShipmentCodeEndswith;
  /**
   * 所属平台仓发货单的发货单号 比较(isnull)
   */
  private Boolean parentPlatformshippingShipmentCodeIsnull;
  /**
   * 所属平台仓发货单的发货单号 比较(isnotnull)
   */
  private Boolean parentPlatformshippingShipmentCodeIsnotnull;

  /**
   * 所属平台仓发货单(范围搜索)
   */
  private List<Long> parentPlatformshippingInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 货件单号(模糊搜索)
   */
  private String cargocode;

  /**
   * 货件单号 比较(eq)
   */
  private String cargocodeEq;
  /**
   * 货件单号 比较(neq)
   */
  private String cargocodeNeq;
  /**
   * 货件单号 比较(gt)
   */
  private String cargocodeGt;
  /**
   * 货件单号 比较(gte)
   */
  private String cargocodeGte;
  /**
   * 货件单号 比较(lt)
   */
  private String cargocodeLt;
  /**
   * 货件单号 比较(lte)
   */
  private String cargocodeLte;
  /**
   * 货件单号 比较(contains)
   */
  private String cargocodeContains;
  /**
   * 货件单号 比较(notcontains)
   */
  private String cargocodeNotcontains;
  /**
   * 货件单号 比较(startswith)
   */
  private String cargocodeStartswith;
  /**
   * 货件单号 比较(endswith)
   */
  private String cargocodeEndswith;
  /**
   * 货件单号 比较(isnull)
   */
  private Boolean cargocodeIsnull;
  /**
   * 货件单号 比较(isnotnull)
   */
  private Boolean cargocodeIsnotnull;

  /**
   * 货件单号(精确搜索)
   */
  private List<String> cargocodeInList;

  /**
   * 图片(模糊搜索)
   */
  private String img;

  /**
   * 图片 比较(eq)
   */
  private String imgEq;
  /**
   * 图片 比较(neq)
   */
  private String imgNeq;
  /**
   * 图片 比较(gt)
   */
  private String imgGt;
  /**
   * 图片 比较(gte)
   */
  private String imgGte;
  /**
   * 图片 比较(lt)
   */
  private String imgLt;
  /**
   * 图片 比较(lte)
   */
  private String imgLte;
  /**
   * 图片 比较(contains)
   */
  private String imgContains;
  /**
   * 图片 比较(notcontains)
   */
  private String imgNotcontains;
  /**
   * 图片 比较(startswith)
   */
  private String imgStartswith;
  /**
   * 图片 比较(endswith)
   */
  private String imgEndswith;
  /**
   * 图片 比较(isnull)
   */
  private Boolean imgIsnull;
  /**
   * 图片 比较(isnotnull)
   */
  private Boolean imgIsnotnull;

  /**
   * 图片(精确搜索)
   */
  private List<String> imgInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * GTIN(模糊搜索)
   */
  private String gtin;

  /**
   * GTIN 比较(eq)
   */
  private String gtinEq;
  /**
   * GTIN 比较(neq)
   */
  private String gtinNeq;
  /**
   * GTIN 比较(gt)
   */
  private String gtinGt;
  /**
   * GTIN 比较(gte)
   */
  private String gtinGte;
  /**
   * GTIN 比较(lt)
   */
  private String gtinLt;
  /**
   * GTIN 比较(lte)
   */
  private String gtinLte;
  /**
   * GTIN 比较(contains)
   */
  private String gtinContains;
  /**
   * GTIN 比较(notcontains)
   */
  private String gtinNotcontains;
  /**
   * GTIN 比较(startswith)
   */
  private String gtinStartswith;
  /**
   * GTIN 比较(endswith)
   */
  private String gtinEndswith;
  /**
   * GTIN 比较(isnull)
   */
  private Boolean gtinIsnull;
  /**
   * GTIN 比较(isnotnull)
   */
  private Boolean gtinIsnotnull;

  /**
   * GTIN(精确搜索)
   */
  private List<String> gtinInList;

  /**
   * 品名
   */
  private Long productName;

  /**
   * 品名 比较(eq)
   */
  private Long productNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long productNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long productNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long productNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long productNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String productNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String productNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String productNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String productNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String productNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String productNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String productNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String productNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String productNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String productNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean productNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean productNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> productNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 平台(模糊搜索)
   */
  private String platformname;

  /**
   * 平台 比较(eq)
   */
  private String platformnameEq;
  /**
   * 平台 比较(neq)
   */
  private String platformnameNeq;
  /**
   * 平台 比较(gt)
   */
  private String platformnameGt;
  /**
   * 平台 比较(gte)
   */
  private String platformnameGte;
  /**
   * 平台 比较(lt)
   */
  private String platformnameLt;
  /**
   * 平台 比较(lte)
   */
  private String platformnameLte;
  /**
   * 平台 比较(contains)
   */
  private String platformnameContains;
  /**
   * 平台 比较(notcontains)
   */
  private String platformnameNotcontains;
  /**
   * 平台 比较(startswith)
   */
  private String platformnameStartswith;
  /**
   * 平台 比较(endswith)
   */
  private String platformnameEndswith;
  /**
   * 平台 比较(isnull)
   */
  private Boolean platformnameIsnull;
  /**
   * 平台 比较(isnotnull)
   */
  private Boolean platformnameIsnotnull;

  /**
   * 平台(精确搜索)
   */
  private List<String> platformnameInList;

  /**
   * 店铺
   */
  private Long shopId;

  /**
   * 店铺 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopIdShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopIdShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopIdShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopIdShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopIdShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopIdShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopIdShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopIdShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopIdShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopIdShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopIdShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopIdShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopIdInList;

  /**
   * 国家(模糊搜索)
   */
  private String countryname;

  /**
   * 国家 比较(eq)
   */
  private String countrynameEq;
  /**
   * 国家 比较(neq)
   */
  private String countrynameNeq;
  /**
   * 国家 比较(gt)
   */
  private String countrynameGt;
  /**
   * 国家 比较(gte)
   */
  private String countrynameGte;
  /**
   * 国家 比较(lt)
   */
  private String countrynameLt;
  /**
   * 国家 比较(lte)
   */
  private String countrynameLte;
  /**
   * 国家 比较(contains)
   */
  private String countrynameContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countrynameNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countrynameStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countrynameEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countrynameIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countrynameIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countrynameInList;

  /**
   * 申报量
   */
  private Integer applynum;

  /**
   * 最小申报量
   */
  private Integer applynumMin;

  /**
   * 最大申报量
   */
  private Integer applynumMax;

  /**
   * 申报量 比较(eq)
   */
  private Integer applynumEq;
  /**
   * 申报量 比较(neq)
   */
  private Integer applynumNeq;
  /**
   * 申报量 比较(gt)
   */
  private Integer applynumGt;
  /**
   * 申报量 比较(gte)
   */
  private Integer applynumGte;
  /**
   * 申报量 比较(lt)
   */
  private Integer applynumLt;
  /**
   * 申报量 比较(lte)
   */
  private Integer applynumLte;
  /**
   * 申报量 比较(contains)
   */
  private Integer applynumContains;
  /**
   * 申报量 比较(notcontains)
   */
  private Integer applynumNotcontains;
  /**
   * 申报量 比较(startswith)
   */
  private Integer applynumStartswith;
  /**
   * 申报量 比较(endswith)
   */
  private Integer applynumEndswith;
  /**
   * 申报量 比较(isnull)
   */
  private Boolean applynumIsnull;
  /**
   * 申报量 比较(isnotnull)
   */
  private Boolean applynumIsnotnull;

  /**
   * 发货量
   */
  private Integer shipmentsnum;

  /**
   * 最小发货量
   */
  private Integer shipmentsnumMin;

  /**
   * 最大发货量
   */
  private Integer shipmentsnumMax;

  /**
   * 发货量 比较(eq)
   */
  private Integer shipmentsnumEq;
  /**
   * 发货量 比较(neq)
   */
  private Integer shipmentsnumNeq;
  /**
   * 发货量 比较(gt)
   */
  private Integer shipmentsnumGt;
  /**
   * 发货量 比较(gte)
   */
  private Integer shipmentsnumGte;
  /**
   * 发货量 比较(lt)
   */
  private Integer shipmentsnumLt;
  /**
   * 发货量 比较(lte)
   */
  private Integer shipmentsnumLte;
  /**
   * 发货量 比较(contains)
   */
  private Integer shipmentsnumContains;
  /**
   * 发货量 比较(notcontains)
   */
  private Integer shipmentsnumNotcontains;
  /**
   * 发货量 比较(startswith)
   */
  private Integer shipmentsnumStartswith;
  /**
   * 发货量 比较(endswith)
   */
  private Integer shipmentsnumEndswith;
  /**
   * 发货量 比较(isnull)
   */
  private Boolean shipmentsnumIsnull;
  /**
   * 发货量 比较(isnotnull)
   */
  private Boolean shipmentsnumIsnotnull;

  /**
   * 箱规名称
   */
  private String boxgaugename;

  /**
   * 箱规名称 比较(eq)
   */
  private String boxgaugenameEq;
  /**
   * 箱规名称 比较(neq)
   */
  private String boxgaugenameNeq;
  /**
   * 箱规名称 比较(gt)
   */
  private String boxgaugenameGt;
  /**
   * 箱规名称 比较(gte)
   */
  private String boxgaugenameGte;
  /**
   * 箱规名称 比较(lt)
   */
  private String boxgaugenameLt;
  /**
   * 箱规名称 比较(lte)
   */
  private String boxgaugenameLte;
  /**
   * 箱规名称 比较(contains)
   */
  private String boxgaugenameContains;
  /**
   * 箱规名称 比较(notcontains)
   */
  private String boxgaugenameNotcontains;
  /**
   * 箱规名称 比较(startswith)
   */
  private String boxgaugenameStartswith;
  /**
   * 箱规名称 比较(endswith)
   */
  private String boxgaugenameEndswith;
  /**
   * 箱规名称 比较(isnull)
   */
  private Boolean boxgaugenameIsnull;
  /**
   * 箱规名称 比较(isnotnull)
   */
  private Boolean boxgaugenameIsnotnull;

  /**
   * 箱规名称(精确搜索)
   */
  private List<String> boxgaugenameInList;

  /**
   * 单箱数量
   */
  private Integer quantityincase;

  /**
   * 最小单箱数量
   */
  private Integer quantityincaseMin;

  /**
   * 最大单箱数量
   */
  private Integer quantityincaseMax;

  /**
   * 单箱数量 比较(eq)
   */
  private Integer quantityincaseEq;
  /**
   * 单箱数量 比较(neq)
   */
  private Integer quantityincaseNeq;
  /**
   * 单箱数量 比较(gt)
   */
  private Integer quantityincaseGt;
  /**
   * 单箱数量 比较(gte)
   */
  private Integer quantityincaseGte;
  /**
   * 单箱数量 比较(lt)
   */
  private Integer quantityincaseLt;
  /**
   * 单箱数量 比较(lte)
   */
  private Integer quantityincaseLte;
  /**
   * 单箱数量 比较(contains)
   */
  private Integer quantityincaseContains;
  /**
   * 单箱数量 比较(notcontains)
   */
  private Integer quantityincaseNotcontains;
  /**
   * 单箱数量 比较(startswith)
   */
  private Integer quantityincaseStartswith;
  /**
   * 单箱数量 比较(endswith)
   */
  private Integer quantityincaseEndswith;
  /**
   * 单箱数量 比较(isnull)
   */
  private Boolean quantityincaseIsnull;
  /**
   * 单箱数量 比较(isnotnull)
   */
  private Boolean quantityincaseIsnotnull;

  /**
   * 箱数
   */
  private Integer boxnum;

  /**
   * 最小箱数
   */
  private Integer boxnumMin;

  /**
   * 最大箱数
   */
  private Integer boxnumMax;

  /**
   * 箱数 比较(eq)
   */
  private Integer boxnumEq;
  /**
   * 箱数 比较(neq)
   */
  private Integer boxnumNeq;
  /**
   * 箱数 比较(gt)
   */
  private Integer boxnumGt;
  /**
   * 箱数 比较(gte)
   */
  private Integer boxnumGte;
  /**
   * 箱数 比较(lt)
   */
  private Integer boxnumLt;
  /**
   * 箱数 比较(lte)
   */
  private Integer boxnumLte;
  /**
   * 箱数 比较(contains)
   */
  private Integer boxnumContains;
  /**
   * 箱数 比较(notcontains)
   */
  private Integer boxnumNotcontains;
  /**
   * 箱数 比较(startswith)
   */
  private Integer boxnumStartswith;
  /**
   * 箱数 比较(endswith)
   */
  private Integer boxnumEndswith;
  /**
   * 箱数 比较(isnull)
   */
  private Boolean boxnumIsnull;
  /**
   * 箱数 比较(isnotnull)
   */
  private Boolean boxnumIsnotnull;

  /**
   * 箱规(长)
   */
  private java.math.BigDecimal cbmlong;

  /**
   * 最小箱规(长)
   */
  private java.math.BigDecimal cbmlongMin;

  /**
   * 最大箱规(长)
   */
  private java.math.BigDecimal cbmlongMax;

  /**
   * 箱规(长) 比较(eq)
   */
  private java.math.BigDecimal cbmlongEq;
  /**
   * 箱规(长) 比较(neq)
   */
  private java.math.BigDecimal cbmlongNeq;
  /**
   * 箱规(长) 比较(gt)
   */
  private java.math.BigDecimal cbmlongGt;
  /**
   * 箱规(长) 比较(gte)
   */
  private java.math.BigDecimal cbmlongGte;
  /**
   * 箱规(长) 比较(lt)
   */
  private java.math.BigDecimal cbmlongLt;
  /**
   * 箱规(长) 比较(lte)
   */
  private java.math.BigDecimal cbmlongLte;
  /**
   * 箱规(长) 比较(contains)
   */
  private java.math.BigDecimal cbmlongContains;
  /**
   * 箱规(长) 比较(notcontains)
   */
  private java.math.BigDecimal cbmlongNotcontains;
  /**
   * 箱规(长) 比较(startswith)
   */
  private java.math.BigDecimal cbmlongStartswith;
  /**
   * 箱规(长) 比较(endswith)
   */
  private java.math.BigDecimal cbmlongEndswith;
  /**
   * 箱规(长) 比较(isnull)
   */
  private Boolean cbmlongIsnull;
  /**
   * 箱规(长) 比较(isnotnull)
   */
  private Boolean cbmlongIsnotnull;

  /**
   * 箱规(宽)
   */
  private java.math.BigDecimal cbmwide;

  /**
   * 最小箱规(宽)
   */
  private java.math.BigDecimal cbmwideMin;

  /**
   * 最大箱规(宽)
   */
  private java.math.BigDecimal cbmwideMax;

  /**
   * 箱规(宽) 比较(eq)
   */
  private java.math.BigDecimal cbmwideEq;
  /**
   * 箱规(宽) 比较(neq)
   */
  private java.math.BigDecimal cbmwideNeq;
  /**
   * 箱规(宽) 比较(gt)
   */
  private java.math.BigDecimal cbmwideGt;
  /**
   * 箱规(宽) 比较(gte)
   */
  private java.math.BigDecimal cbmwideGte;
  /**
   * 箱规(宽) 比较(lt)
   */
  private java.math.BigDecimal cbmwideLt;
  /**
   * 箱规(宽) 比较(lte)
   */
  private java.math.BigDecimal cbmwideLte;
  /**
   * 箱规(宽) 比较(contains)
   */
  private java.math.BigDecimal cbmwideContains;
  /**
   * 箱规(宽) 比较(notcontains)
   */
  private java.math.BigDecimal cbmwideNotcontains;
  /**
   * 箱规(宽) 比较(startswith)
   */
  private java.math.BigDecimal cbmwideStartswith;
  /**
   * 箱规(宽) 比较(endswith)
   */
  private java.math.BigDecimal cbmwideEndswith;
  /**
   * 箱规(宽) 比较(isnull)
   */
  private Boolean cbmwideIsnull;
  /**
   * 箱规(宽) 比较(isnotnull)
   */
  private Boolean cbmwideIsnotnull;

  /**
   * 箱规(高)
   */
  private java.math.BigDecimal cbmtall;

  /**
   * 最小箱规(高)
   */
  private java.math.BigDecimal cbmtallMin;

  /**
   * 最大箱规(高)
   */
  private java.math.BigDecimal cbmtallMax;

  /**
   * 箱规(高) 比较(eq)
   */
  private java.math.BigDecimal cbmtallEq;
  /**
   * 箱规(高) 比较(neq)
   */
  private java.math.BigDecimal cbmtallNeq;
  /**
   * 箱规(高) 比较(gt)
   */
  private java.math.BigDecimal cbmtallGt;
  /**
   * 箱规(高) 比较(gte)
   */
  private java.math.BigDecimal cbmtallGte;
  /**
   * 箱规(高) 比较(lt)
   */
  private java.math.BigDecimal cbmtallLt;
  /**
   * 箱规(高) 比较(lte)
   */
  private java.math.BigDecimal cbmtallLte;
  /**
   * 箱规(高) 比较(contains)
   */
  private java.math.BigDecimal cbmtallContains;
  /**
   * 箱规(高) 比较(notcontains)
   */
  private java.math.BigDecimal cbmtallNotcontains;
  /**
   * 箱规(高) 比较(startswith)
   */
  private java.math.BigDecimal cbmtallStartswith;
  /**
   * 箱规(高) 比较(endswith)
   */
  private java.math.BigDecimal cbmtallEndswith;
  /**
   * 箱规(高) 比较(isnull)
   */
  private Boolean cbmtallIsnull;
  /**
   * 箱规(高) 比较(isnotnull)
   */
  private Boolean cbmtallIsnotnull;

  /**
   * 产品箱规(长)
   */
  private java.math.BigDecimal specInfolong;

  /**
   * 最小产品箱规(长)
   */
  private java.math.BigDecimal specInfolongMin;

  /**
   * 最大产品箱规(长)
   */
  private java.math.BigDecimal specInfolongMax;

  /**
   * 产品箱规(长) 比较(eq)
   */
  private java.math.BigDecimal specInfolongEq;
  /**
   * 产品箱规(长) 比较(neq)
   */
  private java.math.BigDecimal specInfolongNeq;
  /**
   * 产品箱规(长) 比较(gt)
   */
  private java.math.BigDecimal specInfolongGt;
  /**
   * 产品箱规(长) 比较(gte)
   */
  private java.math.BigDecimal specInfolongGte;
  /**
   * 产品箱规(长) 比较(lt)
   */
  private java.math.BigDecimal specInfolongLt;
  /**
   * 产品箱规(长) 比较(lte)
   */
  private java.math.BigDecimal specInfolongLte;
  /**
   * 产品箱规(长) 比较(contains)
   */
  private java.math.BigDecimal specInfolongContains;
  /**
   * 产品箱规(长) 比较(notcontains)
   */
  private java.math.BigDecimal specInfolongNotcontains;
  /**
   * 产品箱规(长) 比较(startswith)
   */
  private java.math.BigDecimal specInfolongStartswith;
  /**
   * 产品箱规(长) 比较(endswith)
   */
  private java.math.BigDecimal specInfolongEndswith;
  /**
   * 产品箱规(长) 比较(isnull)
   */
  private Boolean specInfolongIsnull;
  /**
   * 产品箱规(长) 比较(isnotnull)
   */
  private Boolean specInfolongIsnotnull;

  /**
   * 产品箱规(宽)
   */
  private java.math.BigDecimal specInfowide;

  /**
   * 最小产品箱规(宽)
   */
  private java.math.BigDecimal specInfowideMin;

  /**
   * 最大产品箱规(宽)
   */
  private java.math.BigDecimal specInfowideMax;

  /**
   * 产品箱规(宽) 比较(eq)
   */
  private java.math.BigDecimal specInfowideEq;
  /**
   * 产品箱规(宽) 比较(neq)
   */
  private java.math.BigDecimal specInfowideNeq;
  /**
   * 产品箱规(宽) 比较(gt)
   */
  private java.math.BigDecimal specInfowideGt;
  /**
   * 产品箱规(宽) 比较(gte)
   */
  private java.math.BigDecimal specInfowideGte;
  /**
   * 产品箱规(宽) 比较(lt)
   */
  private java.math.BigDecimal specInfowideLt;
  /**
   * 产品箱规(宽) 比较(lte)
   */
  private java.math.BigDecimal specInfowideLte;
  /**
   * 产品箱规(宽) 比较(contains)
   */
  private java.math.BigDecimal specInfowideContains;
  /**
   * 产品箱规(宽) 比较(notcontains)
   */
  private java.math.BigDecimal specInfowideNotcontains;
  /**
   * 产品箱规(宽) 比较(startswith)
   */
  private java.math.BigDecimal specInfowideStartswith;
  /**
   * 产品箱规(宽) 比较(endswith)
   */
  private java.math.BigDecimal specInfowideEndswith;
  /**
   * 产品箱规(宽) 比较(isnull)
   */
  private Boolean specInfowideIsnull;
  /**
   * 产品箱规(宽) 比较(isnotnull)
   */
  private Boolean specInfowideIsnotnull;

  /**
   * 产品箱规(高)
   */
  private java.math.BigDecimal specInfotall;

  /**
   * 最小产品箱规(高)
   */
  private java.math.BigDecimal specInfotallMin;

  /**
   * 最大产品箱规(高)
   */
  private java.math.BigDecimal specInfotallMax;

  /**
   * 产品箱规(高) 比较(eq)
   */
  private java.math.BigDecimal specInfotallEq;
  /**
   * 产品箱规(高) 比较(neq)
   */
  private java.math.BigDecimal specInfotallNeq;
  /**
   * 产品箱规(高) 比较(gt)
   */
  private java.math.BigDecimal specInfotallGt;
  /**
   * 产品箱规(高) 比较(gte)
   */
  private java.math.BigDecimal specInfotallGte;
  /**
   * 产品箱规(高) 比较(lt)
   */
  private java.math.BigDecimal specInfotallLt;
  /**
   * 产品箱规(高) 比较(lte)
   */
  private java.math.BigDecimal specInfotallLte;
  /**
   * 产品箱规(高) 比较(contains)
   */
  private java.math.BigDecimal specInfotallContains;
  /**
   * 产品箱规(高) 比较(notcontains)
   */
  private java.math.BigDecimal specInfotallNotcontains;
  /**
   * 产品箱规(高) 比较(startswith)
   */
  private java.math.BigDecimal specInfotallStartswith;
  /**
   * 产品箱规(高) 比较(endswith)
   */
  private java.math.BigDecimal specInfotallEndswith;
  /**
   * 产品箱规(高) 比较(isnull)
   */
  private Boolean specInfotallIsnull;
  /**
   * 产品箱规(高) 比较(isnotnull)
   */
  private Boolean specInfotallIsnotnull;

  /**
   * CBM(M3)
   */
  private java.math.BigDecimal cbm;

  /**
   * 最小CBM(M3)
   */
  private java.math.BigDecimal cbmMin;

  /**
   * 最大CBM(M3)
   */
  private java.math.BigDecimal cbmMax;

  /**
   * CBM(M3) 比较(eq)
   */
  private java.math.BigDecimal cbmEq;
  /**
   * CBM(M3) 比较(neq)
   */
  private java.math.BigDecimal cbmNeq;
  /**
   * CBM(M3) 比较(gt)
   */
  private java.math.BigDecimal cbmGt;
  /**
   * CBM(M3) 比较(gte)
   */
  private java.math.BigDecimal cbmGte;
  /**
   * CBM(M3) 比较(lt)
   */
  private java.math.BigDecimal cbmLt;
  /**
   * CBM(M3) 比较(lte)
   */
  private java.math.BigDecimal cbmLte;
  /**
   * CBM(M3) 比较(contains)
   */
  private java.math.BigDecimal cbmContains;
  /**
   * CBM(M3) 比较(notcontains)
   */
  private java.math.BigDecimal cbmNotcontains;
  /**
   * CBM(M3) 比较(startswith)
   */
  private java.math.BigDecimal cbmStartswith;
  /**
   * CBM(M3) 比较(endswith)
   */
  private java.math.BigDecimal cbmEndswith;
  /**
   * CBM(M3) 比较(isnull)
   */
  private Boolean cbmIsnull;
  /**
   * CBM(M3) 比较(isnotnull)
   */
  private Boolean cbmIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 单品净重(g)
   */
  private java.math.BigDecimal cgproductnetweight;

  /**
   * 最小单品净重(g)
   */
  private java.math.BigDecimal cgproductnetweightMin;

  /**
   * 最大单品净重(g)
   */
  private java.math.BigDecimal cgproductnetweightMax;

  /**
   * 单品净重(g) 比较(eq)
   */
  private java.math.BigDecimal cgproductnetweightEq;
  /**
   * 单品净重(g) 比较(neq)
   */
  private java.math.BigDecimal cgproductnetweightNeq;
  /**
   * 单品净重(g) 比较(gt)
   */
  private java.math.BigDecimal cgproductnetweightGt;
  /**
   * 单品净重(g) 比较(gte)
   */
  private java.math.BigDecimal cgproductnetweightGte;
  /**
   * 单品净重(g) 比较(lt)
   */
  private java.math.BigDecimal cgproductnetweightLt;
  /**
   * 单品净重(g) 比较(lte)
   */
  private java.math.BigDecimal cgproductnetweightLte;
  /**
   * 单品净重(g) 比较(contains)
   */
  private java.math.BigDecimal cgproductnetweightContains;
  /**
   * 单品净重(g) 比较(notcontains)
   */
  private java.math.BigDecimal cgproductnetweightNotcontains;
  /**
   * 单品净重(g) 比较(startswith)
   */
  private java.math.BigDecimal cgproductnetweightStartswith;
  /**
   * 单品净重(g) 比较(endswith)
   */
  private java.math.BigDecimal cgproductnetweightEndswith;
  /**
   * 单品净重(g) 比较(isnull)
   */
  private Boolean cgproductnetweightIsnull;
  /**
   * 单品净重(g) 比较(isnotnull)
   */
  private Boolean cgproductnetweightIsnotnull;

  /**
   * 单品毛重(g)
   */
  private java.math.BigDecimal cgproductgrossweight;

  /**
   * 最小单品毛重(g)
   */
  private java.math.BigDecimal cgproductgrossweightMin;

  /**
   * 最大单品毛重(g)
   */
  private java.math.BigDecimal cgproductgrossweightMax;

  /**
   * 单品毛重(g) 比较(eq)
   */
  private java.math.BigDecimal cgproductgrossweightEq;
  /**
   * 单品毛重(g) 比较(neq)
   */
  private java.math.BigDecimal cgproductgrossweightNeq;
  /**
   * 单品毛重(g) 比较(gt)
   */
  private java.math.BigDecimal cgproductgrossweightGt;
  /**
   * 单品毛重(g) 比较(gte)
   */
  private java.math.BigDecimal cgproductgrossweightGte;
  /**
   * 单品毛重(g) 比较(lt)
   */
  private java.math.BigDecimal cgproductgrossweightLt;
  /**
   * 单品毛重(g) 比较(lte)
   */
  private java.math.BigDecimal cgproductgrossweightLte;
  /**
   * 单品毛重(g) 比较(contains)
   */
  private java.math.BigDecimal cgproductgrossweightContains;
  /**
   * 单品毛重(g) 比较(notcontains)
   */
  private java.math.BigDecimal cgproductgrossweightNotcontains;
  /**
   * 单品毛重(g) 比较(startswith)
   */
  private java.math.BigDecimal cgproductgrossweightStartswith;
  /**
   * 单品毛重(g) 比较(endswith)
   */
  private java.math.BigDecimal cgproductgrossweightEndswith;
  /**
   * 单品毛重(g) 比较(isnull)
   */
  private Boolean cgproductgrossweightIsnull;
  /**
   * 单品毛重(g) 比较(isnotnull)
   */
  private Boolean cgproductgrossweightIsnotnull;

  /**
   * 单品重量(kg)
   */
  private java.math.BigDecimal cgproductweight;

  /**
   * 最小单品重量(kg)
   */
  private java.math.BigDecimal cgproductweightMin;

  /**
   * 最大单品重量(kg)
   */
  private java.math.BigDecimal cgproductweightMax;

  /**
   * 单品重量(kg) 比较(eq)
   */
  private java.math.BigDecimal cgproductweightEq;
  /**
   * 单品重量(kg) 比较(neq)
   */
  private java.math.BigDecimal cgproductweightNeq;
  /**
   * 单品重量(kg) 比较(gt)
   */
  private java.math.BigDecimal cgproductweightGt;
  /**
   * 单品重量(kg) 比较(gte)
   */
  private java.math.BigDecimal cgproductweightGte;
  /**
   * 单品重量(kg) 比较(lt)
   */
  private java.math.BigDecimal cgproductweightLt;
  /**
   * 单品重量(kg) 比较(lte)
   */
  private java.math.BigDecimal cgproductweightLte;
  /**
   * 单品重量(kg) 比较(contains)
   */
  private java.math.BigDecimal cgproductweightContains;
  /**
   * 单品重量(kg) 比较(notcontains)
   */
  private java.math.BigDecimal cgproductweightNotcontains;
  /**
   * 单品重量(kg) 比较(startswith)
   */
  private java.math.BigDecimal cgproductweightStartswith;
  /**
   * 单品重量(kg) 比较(endswith)
   */
  private java.math.BigDecimal cgproductweightEndswith;
  /**
   * 单品重量(kg) 比较(isnull)
   */
  private Boolean cgproductweightIsnull;
  /**
   * 单品重量(kg) 比较(isnotnull)
   */
  private Boolean cgproductweightIsnotnull;

  /**
   * 单箱净重(kg)
   */
  private java.math.BigDecimal cgboxgrossweight;

  /**
   * 最小单箱净重(kg)
   */
  private java.math.BigDecimal cgboxgrossweightMin;

  /**
   * 最大单箱净重(kg)
   */
  private java.math.BigDecimal cgboxgrossweightMax;

  /**
   * 单箱净重(kg) 比较(eq)
   */
  private java.math.BigDecimal cgboxgrossweightEq;
  /**
   * 单箱净重(kg) 比较(neq)
   */
  private java.math.BigDecimal cgboxgrossweightNeq;
  /**
   * 单箱净重(kg) 比较(gt)
   */
  private java.math.BigDecimal cgboxgrossweightGt;
  /**
   * 单箱净重(kg) 比较(gte)
   */
  private java.math.BigDecimal cgboxgrossweightGte;
  /**
   * 单箱净重(kg) 比较(lt)
   */
  private java.math.BigDecimal cgboxgrossweightLt;
  /**
   * 单箱净重(kg) 比较(lte)
   */
  private java.math.BigDecimal cgboxgrossweightLte;
  /**
   * 单箱净重(kg) 比较(contains)
   */
  private java.math.BigDecimal cgboxgrossweightContains;
  /**
   * 单箱净重(kg) 比较(notcontains)
   */
  private java.math.BigDecimal cgboxgrossweightNotcontains;
  /**
   * 单箱净重(kg) 比较(startswith)
   */
  private java.math.BigDecimal cgboxgrossweightStartswith;
  /**
   * 单箱净重(kg) 比较(endswith)
   */
  private java.math.BigDecimal cgboxgrossweightEndswith;
  /**
   * 单箱净重(kg) 比较(isnull)
   */
  private Boolean cgboxgrossweightIsnull;
  /**
   * 单箱净重(kg) 比较(isnotnull)
   */
  private Boolean cgboxgrossweightIsnotnull;

  /**
   * 单箱毛重(kg)
   */
  private java.math.BigDecimal boxgrossweight;

  /**
   * 最小单箱毛重(kg)
   */
  private java.math.BigDecimal boxgrossweightMin;

  /**
   * 最大单箱毛重(kg)
   */
  private java.math.BigDecimal boxgrossweightMax;

  /**
   * 单箱毛重(kg) 比较(eq)
   */
  private java.math.BigDecimal boxgrossweightEq;
  /**
   * 单箱毛重(kg) 比较(neq)
   */
  private java.math.BigDecimal boxgrossweightNeq;
  /**
   * 单箱毛重(kg) 比较(gt)
   */
  private java.math.BigDecimal boxgrossweightGt;
  /**
   * 单箱毛重(kg) 比较(gte)
   */
  private java.math.BigDecimal boxgrossweightGte;
  /**
   * 单箱毛重(kg) 比较(lt)
   */
  private java.math.BigDecimal boxgrossweightLt;
  /**
   * 单箱毛重(kg) 比较(lte)
   */
  private java.math.BigDecimal boxgrossweightLte;
  /**
   * 单箱毛重(kg) 比较(contains)
   */
  private java.math.BigDecimal boxgrossweightContains;
  /**
   * 单箱毛重(kg) 比较(notcontains)
   */
  private java.math.BigDecimal boxgrossweightNotcontains;
  /**
   * 单箱毛重(kg) 比较(startswith)
   */
  private java.math.BigDecimal boxgrossweightStartswith;
  /**
   * 单箱毛重(kg) 比较(endswith)
   */
  private java.math.BigDecimal boxgrossweightEndswith;
  /**
   * 单箱毛重(kg) 比较(isnull)
   */
  private Boolean boxgrossweightIsnull;
  /**
   * 单箱毛重(kg) 比较(isnotnull)
   */
  private Boolean boxgrossweightIsnotnull;

  /**
   * 体积重
   */
  private java.math.BigDecimal volumeweight;

  /**
   * 最小体积重
   */
  private java.math.BigDecimal volumeweightMin;

  /**
   * 最大体积重
   */
  private java.math.BigDecimal volumeweightMax;

  /**
   * 体积重 比较(eq)
   */
  private java.math.BigDecimal volumeweightEq;
  /**
   * 体积重 比较(neq)
   */
  private java.math.BigDecimal volumeweightNeq;
  /**
   * 体积重 比较(gt)
   */
  private java.math.BigDecimal volumeweightGt;
  /**
   * 体积重 比较(gte)
   */
  private java.math.BigDecimal volumeweightGte;
  /**
   * 体积重 比较(lt)
   */
  private java.math.BigDecimal volumeweightLt;
  /**
   * 体积重 比较(lte)
   */
  private java.math.BigDecimal volumeweightLte;
  /**
   * 体积重 比较(contains)
   */
  private java.math.BigDecimal volumeweightContains;
  /**
   * 体积重 比较(notcontains)
   */
  private java.math.BigDecimal volumeweightNotcontains;
  /**
   * 体积重 比较(startswith)
   */
  private java.math.BigDecimal volumeweightStartswith;
  /**
   * 体积重 比较(endswith)
   */
  private java.math.BigDecimal volumeweightEndswith;
  /**
   * 体积重 比较(isnull)
   */
  private Boolean volumeweightIsnull;
  /**
   * 体积重 比较(isnotnull)
   */
  private Boolean volumeweightIsnotnull;

  /**
   * 总净重
   */
  private java.math.BigDecimal totalnw;

  /**
   * 最小总净重
   */
  private java.math.BigDecimal totalnwMin;

  /**
   * 最大总净重
   */
  private java.math.BigDecimal totalnwMax;

  /**
   * 总净重 比较(eq)
   */
  private java.math.BigDecimal totalnwEq;
  /**
   * 总净重 比较(neq)
   */
  private java.math.BigDecimal totalnwNeq;
  /**
   * 总净重 比较(gt)
   */
  private java.math.BigDecimal totalnwGt;
  /**
   * 总净重 比较(gte)
   */
  private java.math.BigDecimal totalnwGte;
  /**
   * 总净重 比较(lt)
   */
  private java.math.BigDecimal totalnwLt;
  /**
   * 总净重 比较(lte)
   */
  private java.math.BigDecimal totalnwLte;
  /**
   * 总净重 比较(contains)
   */
  private java.math.BigDecimal totalnwContains;
  /**
   * 总净重 比较(notcontains)
   */
  private java.math.BigDecimal totalnwNotcontains;
  /**
   * 总净重 比较(startswith)
   */
  private java.math.BigDecimal totalnwStartswith;
  /**
   * 总净重 比较(endswith)
   */
  private java.math.BigDecimal totalnwEndswith;
  /**
   * 总净重 比较(isnull)
   */
  private Boolean totalnwIsnull;
  /**
   * 总净重 比较(isnotnull)
   */
  private Boolean totalnwIsnotnull;

  /**
   * 总毛重
   */
  private java.math.BigDecimal totalgw;

  /**
   * 最小总毛重
   */
  private java.math.BigDecimal totalgwMin;

  /**
   * 最大总毛重
   */
  private java.math.BigDecimal totalgwMax;

  /**
   * 总毛重 比较(eq)
   */
  private java.math.BigDecimal totalgwEq;
  /**
   * 总毛重 比较(neq)
   */
  private java.math.BigDecimal totalgwNeq;
  /**
   * 总毛重 比较(gt)
   */
  private java.math.BigDecimal totalgwGt;
  /**
   * 总毛重 比较(gte)
   */
  private java.math.BigDecimal totalgwGte;
  /**
   * 总毛重 比较(lt)
   */
  private java.math.BigDecimal totalgwLt;
  /**
   * 总毛重 比较(lte)
   */
  private java.math.BigDecimal totalgwLte;
  /**
   * 总毛重 比较(contains)
   */
  private java.math.BigDecimal totalgwContains;
  /**
   * 总毛重 比较(notcontains)
   */
  private java.math.BigDecimal totalgwNotcontains;
  /**
   * 总毛重 比较(startswith)
   */
  private java.math.BigDecimal totalgwStartswith;
  /**
   * 总毛重 比较(endswith)
   */
  private java.math.BigDecimal totalgwEndswith;
  /**
   * 总毛重 比较(isnull)
   */
  private Boolean totalgwIsnull;
  /**
   * 总毛重 比较(isnotnull)
   */
  private Boolean totalgwIsnotnull;

  /**
   * 税费
   */
  private java.math.BigDecimal pertax;

  /**
   * 最小税费
   */
  private java.math.BigDecimal pertaxMin;

  /**
   * 最大税费
   */
  private java.math.BigDecimal pertaxMax;

  /**
   * 税费 比较(eq)
   */
  private java.math.BigDecimal pertaxEq;
  /**
   * 税费 比较(neq)
   */
  private java.math.BigDecimal pertaxNeq;
  /**
   * 税费 比较(gt)
   */
  private java.math.BigDecimal pertaxGt;
  /**
   * 税费 比较(gte)
   */
  private java.math.BigDecimal pertaxGte;
  /**
   * 税费 比较(lt)
   */
  private java.math.BigDecimal pertaxLt;
  /**
   * 税费 比较(lte)
   */
  private java.math.BigDecimal pertaxLte;
  /**
   * 税费 比较(contains)
   */
  private java.math.BigDecimal pertaxContains;
  /**
   * 税费 比较(notcontains)
   */
  private java.math.BigDecimal pertaxNotcontains;
  /**
   * 税费 比较(startswith)
   */
  private java.math.BigDecimal pertaxStartswith;
  /**
   * 税费 比较(endswith)
   */
  private java.math.BigDecimal pertaxEndswith;
  /**
   * 税费 比较(isnull)
   */
  private Boolean pertaxIsnull;
  /**
   * 税费 比较(isnotnull)
   */
  private Boolean pertaxIsnotnull;

  /**
   * 发货仓库店铺
   */
  private Long shippingwarehousestore;

  /**
   * 发货仓库店铺 比较(eq)
   */
  private Long shippingwarehousestoreEq;
  /**
   * 发货仓库店铺 比较(neq)
   */
  private Long shippingwarehousestoreNeq;
  /**
   * 发货仓库店铺 比较(gt)
   */
  private Long shippingwarehousestoreGt;
  /**
   * 发货仓库店铺 比较(gte)
   */
  private Long shippingwarehousestoreGte;
  /**
   * 发货仓库店铺 比较(lt)
   */
  private Long shippingwarehousestoreLt;
  /**
   * 发货仓库店铺 比较(lte)
   */
  private Long shippingwarehousestoreLte;
  /**
   * 发货仓库店铺 比较(contains)
   */
  private Long shippingwarehousestoreContains;
  /**
   * 发货仓库店铺 比较(notcontains)
   */
  private Long shippingwarehousestoreNotcontains;
  /**
   * 发货仓库店铺 比较(startswith)
   */
  private Long shippingwarehousestoreStartswith;
  /**
   * 发货仓库店铺 比较(endswith)
   */
  private Long shippingwarehousestoreEndswith;
  /**
   * 发货仓库店铺 比较(isnull)
   */
  private Boolean shippingwarehousestoreIsnull;
  /**
   * 发货仓库店铺 比较(isnotnull)
   */
  private Boolean shippingwarehousestoreIsnotnull;
  /**
   * 发货仓库店铺的名称 比较(eq)
   */
  private String shippingwarehousestoreShopNameEq;
  /**
   * 发货仓库店铺的名称 比较(neq)
   */
  private String shippingwarehousestoreShopNameNeq;
  /**
   * 发货仓库店铺的名称 比较(gt)
   */
  private String shippingwarehousestoreShopNameGt;
  /**
   * 发货仓库店铺的名称 比较(gte)
   */
  private String shippingwarehousestoreShopNameGte;
  /**
   * 发货仓库店铺的名称 比较(lt)
   */
  private String shippingwarehousestoreShopNameLt;
  /**
   * 发货仓库店铺的名称 比较(lte)
   */
  private String shippingwarehousestoreShopNameLte;
  /**
   * 发货仓库店铺的名称 比较(contains)
   */
  private String shippingwarehousestoreShopNameContains;
  /**
   * 发货仓库店铺的名称 比较(notcontains)
   */
  private String shippingwarehousestoreShopNameNotcontains;
  /**
   * 发货仓库店铺的名称 比较(startswith)
   */
  private String shippingwarehousestoreShopNameStartswith;
  /**
   * 发货仓库店铺的名称 比较(endswith)
   */
  private String shippingwarehousestoreShopNameEndswith;
  /**
   * 发货仓库店铺的名称 比较(isnull)
   */
  private Boolean shippingwarehousestoreShopNameIsnull;
  /**
   * 发货仓库店铺的名称 比较(isnotnull)
   */
  private Boolean shippingwarehousestoreShopNameIsnotnull;

  /**
   * 发货仓库店铺(范围搜索)
   */
  private List<Long> shippingwarehousestoreInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * fnsku(模糊搜索)
   */
  private String fnsku;

  /**
   * fnsku 比较(eq)
   */
  private String fnskuEq;
  /**
   * fnsku 比较(neq)
   */
  private String fnskuNeq;
  /**
   * fnsku 比较(gt)
   */
  private String fnskuGt;
  /**
   * fnsku 比较(gte)
   */
  private String fnskuGte;
  /**
   * fnsku 比较(lt)
   */
  private String fnskuLt;
  /**
   * fnsku 比较(lte)
   */
  private String fnskuLte;
  /**
   * fnsku 比较(contains)
   */
  private String fnskuContains;
  /**
   * fnsku 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * fnsku 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * fnsku 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * fnsku 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * fnsku 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * fnsku(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 仓位
   */
  private Long binid;

  /**
   * 最小仓位
   */
  private Long binidMin;

  /**
   * 最大仓位
   */
  private Long binidMax;

  /**
   * 仓位 比较(eq)
   */
  private Long binidEq;
  /**
   * 仓位 比较(neq)
   */
  private Long binidNeq;
  /**
   * 仓位 比较(gt)
   */
  private Long binidGt;
  /**
   * 仓位 比较(gte)
   */
  private Long binidGte;
  /**
   * 仓位 比较(lt)
   */
  private Long binidLt;
  /**
   * 仓位 比较(lte)
   */
  private Long binidLte;
  /**
   * 仓位 比较(contains)
   */
  private Long binidContains;
  /**
   * 仓位 比较(notcontains)
   */
  private Long binidNotcontains;
  /**
   * 仓位 比较(startswith)
   */
  private Long binidStartswith;
  /**
   * 仓位 比较(endswith)
   */
  private Long binidEndswith;
  /**
   * 仓位 比较(isnull)
   */
  private Boolean binidIsnull;
  /**
   * 仓位 比较(isnotnull)
   */
  private Boolean binidIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
